home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / nfsmount / nfs_prot_clnt.c < prev    next >
C/C++ Source or Header  |  1989-10-10  |  5KB  |  276 lines
  1. #include <rpc/rpc.h>
  2. #include <sys/time.h>
  3. #include "nfs_prot.h"
  4.  
  5. static struct timeval TIMEOUT = { 25, 0 };
  6.  
  7. VoidPtr 
  8. nfsproc_null_2(argp, clnt)
  9.     VoidPtr argp;
  10.     CLIENT *clnt;
  11. {
  12.     static char res;
  13.  
  14.     bzero(&res, sizeof(res));
  15.     if (clnt_call(clnt, NFSPROC_NULL, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
  16.         return (NULL);
  17.     }
  18.     return ((VoidPtr)&res);
  19. }
  20.  
  21.  
  22. attrstat *
  23. nfsproc_getattr_2(argp, clnt)
  24.     nfs_fh *argp;
  25.     CLIENT *clnt;
  26. {
  27.     static attrstat res;
  28.  
  29.     bzero(&res, sizeof(res));
  30.     if (clnt_call(clnt, NFSPROC_GETATTR, xdr_nfs_fh, argp, xdr_attrstat, &res, TIMEOUT) != RPC_SUCCESS) {
  31.         return (NULL);
  32.     }
  33.     return (&res);
  34. }
  35.  
  36.  
  37. attrstat *
  38. nfsproc_setattr_2(argp, clnt)
  39.     sattrargs *argp;
  40.     CLIENT *clnt;
  41. {
  42.     static attrstat res;
  43.  
  44.     bzero(&res, sizeof(res));
  45.     if (clnt_call(clnt, NFSPROC_SETATTR, xdr_sattrargs, argp, xdr_attrstat, &res, TIMEOUT) != RPC_SUCCESS) {
  46.         return (NULL);
  47.     }
  48.     return (&res);
  49. }
  50.  
  51.  
  52. VoidPtr 
  53. nfsproc_root_2(argp, clnt)
  54.     VoidPtr argp;
  55.     CLIENT *clnt;
  56. {
  57.     static char res;
  58.  
  59.     bzero(&res, sizeof(res));
  60.     if (clnt_call(clnt, NFSPROC_ROOT, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
  61.         return (NULL);
  62.     }
  63.     return ((VoidPtr)&res);
  64. }
  65.  
  66.  
  67. diropres *
  68. nfsproc_lookup_2(argp, clnt)
  69.     diropargs *argp;
  70.     CLIENT *clnt;
  71. {
  72.     static diropres res;
  73.  
  74.     bzero(&res, sizeof(res));
  75.     if (clnt_call(clnt, NFSPROC_LOOKUP, xdr_diropargs, argp, xdr_diropres, &res, TIMEOUT) != RPC_SUCCESS) {
  76.         return (NULL);
  77.     }
  78.     return (&res);
  79. }
  80.  
  81.  
  82. readlinkres *
  83. nfsproc_readlink_2(argp, clnt)
  84.     nfs_fh *argp;
  85.     CLIENT *clnt;
  86. {
  87.     static readlinkres res;
  88.  
  89.     bzero(&res, sizeof(res));
  90.     if (clnt_call(clnt, NFSPROC_READLINK, xdr_nfs_fh, argp, xdr_readlinkres, &res, TIMEOUT) != RPC_SUCCESS) {
  91.         return (NULL);
  92.     }
  93.     return (&res);
  94. }
  95.  
  96.  
  97. readres *
  98. nfsproc_read_2(argp, clnt)
  99.     readargs *argp;
  100.     CLIENT *clnt;
  101. {
  102.     static readres res;
  103.  
  104.     bzero(&res, sizeof(res));
  105.     if (clnt_call(clnt, NFSPROC_READ, xdr_readargs, argp, xdr_readres, &res, TIMEOUT) != RPC_SUCCESS) {
  106.         return (NULL);
  107.     }
  108.     return (&res);
  109. }
  110.  
  111.  
  112. VoidPtr 
  113. nfsproc_writecache_2(argp, clnt)
  114.     VoidPtr argp;
  115.     CLIENT *clnt;
  116. {
  117.     static char res;
  118.  
  119.     bzero(&res, sizeof(res));
  120.     if (clnt_call(clnt, NFSPROC_WRITECACHE, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
  121.         return (NULL);
  122.     }
  123.     return ((VoidPtr)&res);
  124. }
  125.  
  126.  
  127. attrstat *
  128. nfsproc_write_2(argp, clnt)
  129.     writeargs *argp;
  130.     CLIENT *clnt;
  131. {
  132.     static attrstat res;
  133.  
  134.     bzero(&res, sizeof(res));
  135.     if (clnt_call(clnt, NFSPROC_WRITE, xdr_writeargs, argp, xdr_attrstat, &res, TIMEOUT) != RPC_SUCCESS) {
  136.         return (NULL);
  137.     }
  138.     return (&res);
  139. }
  140.  
  141.  
  142. diropres *
  143. nfsproc_create_2(argp, clnt)
  144.     createargs *argp;
  145.     CLIENT *clnt;
  146. {
  147.     static diropres res;
  148.  
  149.     bzero(&res, sizeof(res));
  150.     if (clnt_call(clnt, NFSPROC_CREATE, xdr_createargs, argp, xdr_diropres, &res, TIMEOUT) != RPC_SUCCESS) {
  151.         return (NULL);
  152.     }
  153.     return (&res);
  154. }
  155.  
  156.  
  157. nfsstat *
  158. nfsproc_remove_2(argp, clnt)
  159.     diropargs *argp;
  160.     CLIENT *clnt;
  161. {
  162.     static nfsstat res;
  163.  
  164.     bzero(&res, sizeof(res));
  165.     if (clnt_call(clnt, NFSPROC_REMOVE, xdr_diropargs, argp, xdr_nfsstat, &res, TIMEOUT) != RPC_SUCCESS) {
  166.         return (NULL);
  167.     }
  168.     return (&res);
  169. }
  170.  
  171.  
  172. nfsstat *
  173. nfsproc_rename_2(argp, clnt)
  174.     renameargs *argp;
  175.     CLIENT *clnt;
  176. {
  177.     static nfsstat res;
  178.  
  179.     bzero(&res, sizeof(res));
  180.     if (clnt_call(clnt, NFSPROC_RENAME, xdr_renameargs, argp, xdr_nfsstat, &res, TIMEOUT) != RPC_SUCCESS) {
  181.         return (NULL);
  182.     }
  183.     return (&res);
  184. }
  185.  
  186.  
  187. nfsstat *
  188. nfsproc_link_2(argp, clnt)
  189.     linkargs *argp;
  190.     CLIENT *clnt;
  191. {
  192.     static nfsstat res;
  193.  
  194.     bzero(&res, sizeof(res));
  195.     if (clnt_call(clnt, NFSPROC_LINK, xdr_linkargs, argp, xdr_nfsstat, &res, TIMEOUT) != RPC_SUCCESS) {
  196.         return (NULL);
  197.     }
  198.     return (&res);
  199. }
  200.  
  201.  
  202. nfsstat *
  203. nfsproc_symlink_2(argp, clnt)
  204.     symlinkargs *argp;
  205.     CLIENT *clnt;
  206. {
  207.     static nfsstat res;
  208.  
  209.     bzero(&res, sizeof(res));
  210.     if (clnt_call(clnt, NFSPROC_SYMLINK, xdr_symlinkargs, argp, xdr_nfsstat, &res, TIMEOUT) != RPC_SUCCESS) {
  211.         return (NULL);
  212.     }
  213.     return (&res);
  214. }
  215.  
  216.  
  217. diropres *
  218. nfsproc_mkdir_2(argp, clnt)
  219.     createargs *argp;
  220.     CLIENT *clnt;
  221. {
  222.     static diropres res;
  223.  
  224.     bzero(&res, sizeof(res));
  225.     if (clnt_call(clnt, NFSPROC_MKDIR, xdr_createargs, argp, xdr_diropres, &res, TIMEOUT) != RPC_SUCCESS) {
  226.         return (NULL);
  227.     }
  228.     return (&res);
  229. }
  230.  
  231.  
  232. nfsstat *
  233. nfsproc_rmdir_2(argp, clnt)
  234.     diropargs *argp;
  235.     CLIENT *clnt;
  236. {
  237.     static nfsstat res;
  238.  
  239.     bzero(&res, sizeof(res));
  240.     if (clnt_call(clnt, NFSPROC_RMDIR, xdr_diropargs, argp, xdr_nfsstat, &res, TIMEOUT) != RPC_SUCCESS) {
  241.         return (NULL);
  242.     }
  243.     return (&res);
  244. }
  245.  
  246.  
  247. readdirres *
  248. nfsproc_readdir_2(argp, clnt)
  249.     readdirargs *argp;
  250.     CLIENT *clnt;
  251. {
  252.     static readdirres res;
  253.  
  254.     bzero(&res, sizeof(res));
  255.     if (clnt_call(clnt, NFSPROC_READDIR, xdr_readdirargs, argp, xdr_readdirres, &res, TIMEOUT) != RPC_SUCCESS) {
  256.         return (NULL);
  257.     }
  258.     return (&res);
  259. }
  260.  
  261.  
  262. statfsres *
  263. nfsproc_statfs_2(argp, clnt)
  264.     nfs_fh *argp;
  265.     CLIENT *clnt;
  266. {
  267.     static statfsres res;
  268.  
  269.     bzero(&res, sizeof(res));
  270.     if (clnt_call(clnt, NFSPROC_STATFS, xdr_nfs_fh, argp, xdr_statfsres, &res, TIMEOUT) != RPC_SUCCESS) {
  271.         return (NULL);
  272.     }
  273.     return (&res);
  274. }
  275.  
  276.